// 版权归Go作者所有。保留所有权利。
// 此源代码的使用受BSD样式
// 许可证的约束，该许可证可以在许可证文件中找到。

package syscall

import "unsafe"

const _SYS_setgroups = SYS_SETGROUPS

func EpollCreate(size int) (fd int, err error) {
	if size <= 0 {
		return -1, EINVAL
	}
	return EpollCreate1(0)
}

// sys-EpollWait（epfd-int，events[]EpollEvent，msec-int）（n-int，error error）=sys-EPOLL-PWAIT-
// sys-Fchown（fd-int，uid-int，gid-int）（error error）
// sys Fstatfs（fd int，buf*Statfs_t）（error error）
// sys Ftruncate（fd int，length int64）（error error）
// sysnb Getegid（）（egid int）
// sysnb Getuid（）（uid int）
// sys Listen（s int，n int）（error）
// sys Pread（fd int，p[]byte，offset int64）（n int，error error）=sys PREAD64 
// sys Pwrite（fd int，p[]byte，offset int64）（n int，error error）=sys PWRITE64 
// sys Seek（fd int，offset int64，whence int）（off int64，err error）=sys_LSEEK 
// sys SEND FILE（OUTD int，infd int，offset*int，offset*int64，count int）（WRITED int err err）
// sys Setfsuid（uid int）（err err err err err error）
// sys Splice（rfd int，roff*int64，wfd int，woff*int64，len int，flags int）（n int64，error error）

func Renameat(olddirfd int, oldpath string, newdirfd int, newpath string) (err error) {
	return renameat2(olddirfd, oldpath, newdirfd, newpath, 0)
}

func Stat(path string, stat *Stat_t) (err error) {
	return Fstatat(_AT_FDCWD, path, stat, 0)
}

func Lchown(path string, uid int, gid int) (err error) {
	return Fchownat(_AT_FDCWD, path, uid, gid, _AT_SYMLINK_NOFOLLOW)
}

func Lstat(path string, stat *Stat_t) (err error) {
	return Fstatat(_AT_FDCWD, path, stat, _AT_SYMLINK_NOFOLLOW)
}

// sys accept4（s int，rsa*RawSockaddrAny，addrlen*_Socklen，flags int）（fd int，error error）
// sys getsockopt（s int，level int，name int，val unsafe.Pointer，vallen*_Socklen）（error error）
// sysnb getpeername（fd int，rsa*RawSockaddrAny，addrlen*_Socklen）（错误）
// sysnb getsockname（fd int，rsa*RawSockaddrAny，addrlen*_Socklen）（错误）
// sys recvfrom（fd int，p[]字节，flags int，from rawsocklen addrany，from，from，from Socklen，from Socklen*)Socklen，error）
// sys sendto（s int，buf[]字节，flags int，to unsafe.Pointer，addrlen_Socklen）（error error）
// sys recvmsg（s int，msg*Msghdr，flags int）（n int，error error）
// sys sendmsg（s int，msg*Msghdr，flags int，flags int）（n int，error）（n int，error error）
// sys mmap（addr uintpr uintpttr，length，untptr，length，prot，flags int，flags int，fd int，offset int64，flags intr）

type sigset_t struct {
	X__val [16]uint64
}

// sys pselect（nfd int，r*FdSet，w*FdSet，e*FdSet，timeout*Timespec，sigmask*sigset_t）（n int，error error）=sys pselect 6 

func Select(nfd int, r *FdSet, w *FdSet, e *FdSet, timeout *Timeval) (n int, err error) {
	var ts *Timespec
	if timeout != nil {
		ts = &Timespec{Sec: timeout.Sec, Nsec: timeout.Usec * 1000}
	}
	return pselect(nfd, r, w, e, ts, nil)
}

// sysnb Gettimeofday（tv*Timeval）（error error）

func setTimespec(sec, nsec int64) Timespec {
	return Timespec{Sec: sec, Nsec: nsec}
}

func setTimeval(sec, usec int64) Timeval {
	return Timeval{Sec: sec, Usec: usec}
}

func futimesat(dirfd int, path string, tv *[2]Timeval) (err error) {
	if tv == nil {
		return utimensat(dirfd, path, nil, 0)
	}

	ts := []Timespec{
		NsecToTimespec(TimevalToNsec(tv[0])),
		NsecToTimespec(TimevalToNsec(tv[1])),
	}
	return utimensat(dirfd, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
}

func Time(t *Time_t) (Time_t, error) {
	var tv Timeval
	err := Gettimeofday(&tv)
	if err != nil {
		return 0, err
	}
	if t != nil {
		*t = Time_t(tv.Sec)
	}
	return Time_t(tv.Sec), nil
}

func Utime(path string, buf *Utimbuf) error {
	tv := []Timeval{
		{Sec: buf.Actime},
		{Sec: buf.Modtime},
	}
	return Utimes(path, tv)
}

func utimes(path string, tv *[2]Timeval) (err error) {
	if tv == nil {
		return utimensat(_AT_FDCWD, path, nil, 0)
	}

	ts := []Timespec{
		NsecToTimespec(TimevalToNsec(tv[0])),
		NsecToTimespec(TimevalToNsec(tv[1])),
	}
	return utimensat(_AT_FDCWD, path, (*[2]Timespec)(unsafe.Pointer(&ts[0])), 0)
}

func (r *PtraceRegs) PC() uint64 { return r.Pc }

func (r *PtraceRegs) SetPC(pc uint64) { r.Pc = pc }

func (iov *Iovec) SetLen(length int) {
	iov.Len = uint64(length)
}

func (msghdr *Msghdr) SetControllen(length int) {
	msghdr.Controllen = uint64(length)
}

func (cmsg *Cmsghdr) SetLen(length int) {
	cmsg.Len = uint64(length)
}

func InotifyInit() (fd int, err error) {
	return InotifyInit1(0)
}


func Pause() error {
	_, err := ppoll(nil, 0, nil, nil)
	return err
}

func rawVforkSyscall(trap, a1 uintptr) (r1 uintptr, err Errno)
